How to access an element in a list?

[lemorage]

hey, I am a newbie who starts learning gleam not soon. Recently I have been writing some exercises to create lists and write loops. I found it hard to do nested loops and access something in gleam. So a practical problem is how to access a specific position in a list. I searched many tutorials and examples online, but not getting any solution yet. So I wonder if there are any good examples that I can follow.

import gleam/int

let r = int.random(100) // a random index

let a = list.repeat(0, 100) // the list

// how to do `a[r]` here, like python does

[GearsDatapacks]

You don't want to do list access in gleam. Gleam's lists are linked lists, meaning it's O(n) to access an element. You should model your problem differently.

[Hurricane996]

"We don't support dynamic arrays so model your problem in such a way that it will be efficient to perform on linked lists" is quite a big hurdle. I'm struggling to see what the benefit is to the user of not supporting arrays that makes it worth the massive mental overhead of needing to restructure problems to not use random list access. It's certainly not performance, as linked lists are slooooooooooooow

[giacomocavalieri]

That's not what gears suggested! The recommendation is not "model your problem in a way that it will be efficient to perform on linked lists", rather it's "pick an appropriate data structure/algorithm". Porting an imperative algorithm written for a mutable, object-oriented language in a functional and immutable one will prove to be quite hard and inefficient (as the opposite would also be true)! As Louis suggested one would need to program in a functional style.

At first it could take a bit of a mindset shift, so what to do here? It's hard to give a one size fit all solution as each concrete problem might need to use a different data structure. But if one really needs to access items by an index then they could use a Dict(Int, a), this might be more than enough in simple cases. Sometimes one would need to approach the problem in a different way than what they'd be used to in an imperative language, using a different algorithm - a functional one. Sometimes one might want to use a functional array (and there's great libraries for that, like iv).

At the end of the day the choice really comes down to the specific problem one's trying to solve and picking the right algorithm for the language they're using. Hope this was helpful! :)

[lpil]

@Hurricane996 to use a functional language you will need to take a functional approach to solving problems.

There is an overhead to learning a new programming style, but once you have learnt it that goes away, the same as learning OOP or any other style.

As for not supporting arrays specifically: it's because they are very slow and also challenging to use in an immutable functional setting.

[lpil]

Yup, Gears is right! To add to that, you're going to have a hard time if you port Python algorithms to Gleam directly as one is mutable and object oriented, while the other is immutable and functional. You'll need to program in the functional style instead!

[leobm]

Maybe a gleam package like https://hexdocs.pm/iv/index.html could help.
In JS it use native arrays.
In erlang, the array is implemented at the high level via a RRB-Vector (tree structure). This is probably a little slower than in JS.
But remember, many agorithms can also be implemented very well with lists, often even more efficiently. But for certain things, of course, arrays make sense.

[lpil]

It doesn't use native arrays on JavaScript, that would be much slower than its tree implementation as each update would require a full clone of the array.

[leobm]

ah so then I had looked wrong. had seen that here and thought simple JS arrays were used for js. https://gitlab.com/arkandos/iv/-/blob/main/src/iv_ffi.mjs?ref_type=heads