that article says that cairo 1.0 isn't released yet

_This answer was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Newton

In the medium article about 1.0.0 this is shown as the syntax for the for loop

```let sum = 0
for x in iter {
  sum = sum + x;
}```

That doesn't compile for me and loops are not mentioned on github release note.

Will recursion still be necessary if they work as they do in other languages? 

Will it be possible to invoke functions from within the loops?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Will it be possible to invoke functions from within the loops in Cairo 1.0?

How do I interact with my Pathfinder node?

Hey, I have some tokens on my account and would like to send them to another. How to do it in StarkNet.py?

How to send tokens through StarkNet.py?

How can I resolve this issue?


I'm trying to prove that the left uint is smaller than the right uint using this function:


`func main(syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr):`


 `let zero = Uint256(0, 0)`


 `let one = Uint256(1, 0)`


 `let (result) = uint256_signed_lt(zero, one)`


`end`


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/308)_

Cairo Error: 'range_check_ptr' cannot be used as an implicit return value. Consider using a 'with' statement.

does cross-chain bridge produce its own block? or it only verify the blocks from A/B chain?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Does cross-chain bridge produce its own block? Or it only verify the blocks from A/B chain?

Hey folks, do you know how I could read a felt* from ap?

I want to do something like this:

```rs
    let (hello : felt*) = alloc();
    tempvar world : felt* = hello;
    let world_like : felt* = [ap-1];
```

when I do tempvar world = hello, I ensure I add hello (the pointer) to [ap] and then I increase ap so world_like = [ap-1] should be the same thing than world

But I get this error:

```
Cannot assign an expression of type 'felt' to a reference of type 'felt*'.
    let world_like : felt* = [ap-1];
```

When doing a similar code:

```rust
        let (func_pc: felt*) = get_label_location(storage_var);
        _prepare_call(pedersen_ptr, range_check_ptr, len_inputs, inputs + len_inputs);
        call abs ap[11 - 6 * 2];
```

I get ```
Cannot apply subscript-operator to non-pointer, non-tuple type 'felt'.
        call abs ap[11 - 6 * 2];  // removing alloc_locals by calling ap[11-6*2] ?
```

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

how I could read a felt* from ap in Cairo lang?

Looking to call the approve and transfer functions for an erc-20 in the same transaction. Thoughts on how to do this?


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/1218)_

Cairo: How can i approve erc20 and transfer in the same transaction?


I can often make a terminal recursive version of my functions with a little less elegant code. Should I do it because it could reduce the fees or should I keep the unoptimised version?


For example, here is an "unoptimised" function which sums elements of an array:



```
@view
func get_convoy_strength{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(
    convoy_id : felt
) -> (strength : felt):
    alloc_locals
    let (convoyables_len : felt, convoyables : felt*) = get_convoyables(convoy_id)
    return _get_convoyables_strength(convoyables_len, convoyables)
end

```

and here is the tail call optimization:



```
func _get_convoyables_strength_tc{
    syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr
}(convoyables_len : felt, convoyables : felt*, sum : felt) -> (strength : felt):
    if convoyables_len == 0:
        return (sum)
    else:
        let convoyable_id = [convoyables]
        alloc_locals
        let (convoyable_strength) = _get_strength(convoyable_id)
        return _get_convoyables_strength_tc(
            convoyables_len - 1, convoyables + 1, sum + convoyable_strength
        )
    end
end

```

As you can see it's a little less friendly because it requires an additional argument (which will always be 0). On a normal computer this could be optimized to not fill the call stack but as FeedTheFed pointed out, the memory is immutable here so it doesn't seem to be useful. He did say, however, that it could be interesting for "not wasting memory cells for the intermediate return values". It would be very helpful to me to have a more detailed explanation as I'm not sure to understand.


Here is the cairo doc related to this: <https://www.cairo-lang.org/docs/how_cairo_works/functions.html?highlight=tail#tail-recursion>



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/72321871/when-to-use-tail-call-optimization-in-a-cairo-smartcontract)_

Popular tags

Will it be possible to invoke functions from within the loops in Cairo 1.0?

1 answers

Your answer

Related

You may find useful