Logo

Programming-Idioms

  • Python
  • Rust

Idiom #264 Automated passing of array bounds

Pass a two-dimensional integer array a to a procedure foo and print the size of the array in each dimension. Do not pass the bounds manually. Call the procedure with a two-dimensional array.

fn foo<const X: usize, const Y: usize>(_: [[i32;X];Y]) {
    println!("{} {}", Y, X);
}

let a = [
    [1, 2, 3],
    [4, 5, 6],
];
foo(a);
fn foo(matrix: &[Vec<i32>]) {
    let iter = matrix.iter();
    let (vertical, _) = iter.size_hint();
    let horizontal = iter
        .max()
        .expect("empty array!")
        .len();
    println!("{horizontal} by {vertical}");
}

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
    ];
    foo(&matrix);
}

'&[Vec<i32>]' because we just read the Vec instead of consuming it.
This is emphasised with the '&' in front of types inside the functions signature.
'&Vec' can be coerced to '&[...]', which is a borrowed 'slice'.
A 'slice' is an 'array' with an unknown size at compile time.
'(vertical, _)' because 'size_hint()' returns a lower and a possible upper bound (the '_' in this case).
'max()' may return 'None' if the iterator (in this case our array) is empty.
def foo(a):
    print(len(a), len(a[0]))
    return


a = [[1,2,3], [4,5,6]]
foo(a)

foo = lambda a: \
    print(*(len(x) for x in a))
foo(a)
def foo(a):
    print(*(len(x) for x in a))
foo(a)
foo(List<List<int>> a) => print("${a.length} ${a[0].length}");
var a = [
    [1, 2],
    [3, 4],
    [5, 6]
  ];
foo(a);
New implementation...
< > ⌨
tkoenig 
fn foo<const X: usize, const Y: usize>(_: [[i32;X];Y]) {
    println!("{} {}", Y, X);
}

let a = [
    [1, 2, 3],
    [4, 5, 6],
];
foo(a);
fn foo(matrix: &[Vec<i32>]) {
    let iter = matrix.iter();
    let (vertical, _) = iter.size_hint();
    let horizontal = iter
        .max()
        .expect("empty array!")
        .len();
    println!("{horizontal} by {vertical}");
}

fn main() {
    let matrix = vec![
        vec![1, 2, 3],
        vec![4, 5, 6],
    ];
    foo(&matrix);
}
def foo(a):
    print(len(a), len(a[0]))
    return


a = [[1,2,3], [4,5,6]]
foo(a)

foo = lambda a: \
    print(*(len(x) for x in a))
foo(a)
def foo(a):
    print(*(len(x) for x in a))
foo(a)
foo(List<List<int>> a) => print("${a.length} ${a[0].length}");
var a = [
    [1, 2],
    [3, 4],
    [5, 6]
  ];
foo(a);
module x
contains
  subroutine foo(a)
    integer, dimension(:,:) :: a
    print *,size(a,1), size(a,2)
  end subroutine foo
end module x

program main
  use x
  integer, dimension(5,10) :: a
  call foo(a)
end program main
foo :: [[a]] -> IO ()
foo a = print (length a, length $ head a)

main :: IO ()
main = foo [[1, 2, 3], [4, 5, 6]]
int i = 0, m = a.length;
while (i < m) out.println(a[i++].length);
type
  T2DArray = array of array of Integer;

procedure foo(A: T2DArray);
begin
  writeln(Length(A),', ', Length(A[0]));
end;

var A: T2DArray;

begin
  A := T2DArray.Create([1,2,3],[1,2,3]);
  foo(A);  //prints 2, 3
end.
sub foo {
    my ($a) = @_;
    return scalar @{ $a }, scalar @{ $a->[0] };
}

my $a = [[1,2,3], [4,5,6]];
printf "%d %d\n", foo($a);

def foo(ar)
  puts "#{ar.size} #{ar.first.size}"
end

a = [[1,2,3], [4,5,6]]
foo(a)