Is there a way to limit the length of a Listy within the type definition?

Questions
1

Assume a contract template definition that looks as follows:

template foo
  with
    item0: Decimal
    item1: Decimal
    item2: Decimal
    item3: Decimal
    item4: Decimal
  where
    ....

I want to refactor this template to use a list of decimals.

template foo
  with
    items: [Decimal]
  where
    ....

Is there a way to limit the length of items to 5 on a type-level or should one use ensure on the template which would be checked only during runtime?

1 Like
2

Your best option here is ensure. There are some techniques to enforce this type of stuff at the type-level that work in Haskell but in DAML you run into various issues in particular around data-dependencies and even in Haskell the complexity rarely pays off.

1 Like
3

Is there a reason a tuple wouldn’t work here? Assuming that the list length needs to be exactly 5.

type MyItems = (Decimal, Decimal, Decimal, Decimal, Decimal)

Or a record type?

data MyItems = MyItems
  with
    item1 : Decimal
    item2 : Decimal
    ...
  deriving (Eq, Show)
4

Record types and tuples both force an exact number of elements not a limit on the number of elements.

Apart from that, they also make it super hard to do anything generically. E.g., for a list incrementing each element by one is a simple map (+1). For a tuple, you have to define that yourself and you have to define it separately for each tuple length.

1 Like
5

Good point

From the example it seems as if the length of the list will always be 5 as the items were previously parameters on a template (which I think is a record type anyway)

6

Assuming this, I would go further and put

data List5 a = List5 { a0: a, a1: a, a2: a, a3: a, a4: a }
  deriving (Eq, Show, Ord, Functor, Foldable, Traversable)

which gives you a good number of “list” operations such as @cocreature mentions without having to define them yourself, such as fmap (+1) and for.

I can’t speak to the complications with data-dependencies that @cocreature mentions, though.

2 Likes
7

@stephen’s definition is perfectly fine wtr to data-dependencies and is indeed a good option if you want a fixed length rather than a limit on the length (which is how I read the question initially). It still has the downside that you have to define separate types for each length of list which can get a bit messy.

1 Like
8

The use case I was looking at definitely intended to limit the size, not have a fixed size list. Still very good inputs. thank you very much all!

1 Like