Summary

Latest Version	Unknown
License	MIT or Apache 2.0
CI Status	Passing
Downloads	0
Last Indexed	2026-07-21 05:24

Installation

nimble install loopfusion

choosenim install loopfusion

git clone https://github.com/numforge/loopfusion

OS Compatibility

Platform	Linux	macOS	Windows	FreeBSD	OpenBSD	NetBSD	Android	iOS	WASM	Embedded
loopfusion	✓	✓	✓	-	-	-	-	-	-	-

Source

Repository	https://github.com/numforge/loopfusion
Homepage	https://github.com/numforge/loopfusion
Documentation	View Documentation
Registry Source	nimble_official

README

Loop Fusion

Iterate efficiently over a variadic number of containers.

The loop structure is generated inline at compile-time.
There are no temporary allocation.

Status

The containers can be any number of seq, arrays or openarray of any subtype. You can enumerate on a loop index of your choice, it must be the first parameter.

Usage

import loopfusion

block: # Simple
  let a = @[1, 2, 3]
  let b = @[11, 12, 13]
  let c = @[10, 10, 10]

  forZip x in a, y in b, z in c:
    echo (x + y) * z

  # 120
  # 140
  # 160

block: # With index
  let a = @[1, 2, 3]
  let b = @[11, 12, 13]
  let c = @[10, 10, 10]
  var d: seq[int] = @[]

  forZip i, x in a, y in b, z in c:
    d.add i + x + y + z

  doAssert d == @[22, 25, 28]

block: # With mutation
  var a = @[1, 2, 3]
  let b = @[11, 12, 13]
  let c = @[10, 10, 10]

  forZip x in var a, y in b, z in c:
    x += y * z

  doAssert a == @[111, 122, 133]

block: # With mutation, index and multiple statements
  var a = @[1, 2, 3]
  let b = @[11, 12, 13]
  let c = @[10, 10, 10]

  forZip i, x in var a, y in b, z in c:
    let tmp = i * (y - z)
    x += tmp

  doAssert a == @[1, 4, 9]

block: # With iteration on seq of different types
  let a = @[1, 2, 3]
  let b = @[false, true, true]

  forZip integer in a, boolean in b:
    if boolean:
      echo integer

block: # With an expression
  let a = @[1, 2, 3]
  let b = @[4, 5, 6]


  let c = forZip(x in a, y in b):
    x + y

  doAssert c == @[5, 7, 9]


block: # With arrays + seq, mutation, index and multiple statements
  var a = [1, 2, 3]
  let b = [11, 12, 13]
  let c = @[10, 10, 10]

  forZip i, x in var a, y in b, z in c:
    let tmp = i * (y - z)
    x += tmp

  doAssert a == [1, 4, 9]

Expressions must return value of the same types, i.e. you can't return void/no value at some iterations and a concrete value at other iterations.

Due to parsing limitations, expressions let foo = forZip(...) require parenthesis.

Name

The library name "Loop fusion" might be a bit confusing since there is no loop to fuse at start. In spirit however, it is similar while "real" loop fusion merge multiple loops over multiple sequences.

It's also marketable =) (check loop fusion + \<insert favorite language>)

Implementation details

Many would probably be curious why I first generate a zip iterator then a for-loop instead of for-looping directly.

This is because it started as a variadic zip proof of concept for Arraymancer for which I need an iterator to abstract iteration details, especially in the context of multithreading.

There should be no performance cost as Nim inlines iterators as if the loop was written manually.

loopfusion