{"record":{"id":"9510f3f18f367879","repo":"louthy/language-ext","slug":"can-t-create-an-iterablene-from-an-empty-sequence","errorCode":null,"errorMessage":"Can't create an IterableNE from an empty sequence","messagePattern":"Can't create an IterableNE from an empty sequence","errorType":"exception","errorClass":"ArgumentException","httpStatus":null,"severity":"error","filePath":"LanguageExt.Core/Immutable Collections/IterableNE/IterableNE.Module.cs","lineNumber":119,"sourceCode":"        var iter = Iterator.from(items);\n        if (iter.IsEmpty) return None;\n        var head = iter.Head;\n        var tail = iter.Tail.AsIterable();\n        return new IterableNE<A>(head, tail);\n    }\n\n    /// <summary>\n    /// Create a sequence from an initial set of items\n    /// </summary>\n    /// <param name=\"items\">Items</param>\n    /// <returns>sequence</returns>\n    [Pure]\n    [MethodImpl(MethodImplOptions.AggressiveInlining)]\n    public static IO<IterableNE<A>> createRange<A>(IAsyncEnumerable<A> items) =>\n        IO.liftVAsync(async _ =>\n                      {\n                          var iter = IteratorAsync.from(items);\n                          if (await iter.IsEmpty) throw new ArgumentException(\"Can't create an IterableNE from an empty sequence\");\n                          var head = await iter.Head;\n                          var tail = (await iter.Tail).AsIterable();\n                          return new IterableNE<A>(head, tail);\n                      });\n\n    /// <summary>\n    /// Create a sequence from an initial set of items\n    /// </summary>\n    /// <param name=\"items\">Items</param>\n    /// <returns>sequence</returns>\n    [Pure]\n    [MethodImpl(MethodImplOptions.AggressiveInlining)]\n    public static IO<IterableNE<A>> createRange<A>(Iterable<A> items)\n    {\n        return IO.liftVAsync(_ => items.IsAsync\n                                      ? async()\n                                      : sync());\n    ","sourceCodeStart":101,"sourceCodeEnd":137,"githubUrl":"https://github.com/louthy/language-ext/blob/2f0e3628242889774d4141960a35671a0280051f/LanguageExt.Core/Immutable Collections/IterableNE/IterableNE.Module.cs#L101-L137","documentation":"IterableNE is LanguageExt's non-empty iterable type: it structurally guarantees at least one element (head + tail). createRange<A>(IAsyncEnumerable<A>) must uphold that invariant, so when the async source yields no elements it throws ArgumentException(\"Can't create an IterableNE from an empty sequence\").","triggerScenarios":"Calling IterableNE.createRange on an IAsyncEnumerable<A> whose first await iter.IsEmpty is true — i.e. the source produces zero items (public API createRange in IterableNE.Module.cs:119).","commonSituations":"Querying a database/collection that turned out to be empty; filtering removed all elements upstream; passing an empty array/List.AsEnumerable() to createRange; assuming a source is non-empty after refactoring; first-element access on empty streams.","solutions":["Check emptiness before calling: materialize to a list and use Count == 0 guard, or use IteratorAsync.from(items).IsEmpty first","If emptiness is legal in your domain, return Option<IterableNE<A>>/Iterable (possibly-empty) instead of IterableNE","Provide a default element or fallback sequence when the source is empty","Throw/propagate a domain-specific error with context (which source was empty) rather than the bare ArgumentException"],"exampleFix":"// before\nvar ne = IterableNE.createRange(items); // throws when items is empty\n// after\nvar arr = await items.ToListAsync();\nvar ne = arr.Count == 0\n    ? IterableNE.createRange(fallback)\n    : IterableNE.createRange(arr.ToAsyncEnumerable());","handlingStrategy":"validation","validationCode":"public static async Task<bool> IsEmptyAsync<T>(IAsyncEnumerable<T> src)\n{\n    await foreach (var _ in src) return false;\n    return true;\n}\n// call before createRange:\n// if (await IsEmptyAsync(items)) { /* handle empty */ }","typeGuard":"async Task<Option<IterableNE<A>>> TryCreateRange<A>(IAsyncEnumerable<A> items)\n{\n    var iter = IteratorAsync.from(items);\n    if (await iter.IsEmpty) return Option<IterableNE<A>>.None;\n    return await IterableNE.createRange(items);\n}","tryCatchPattern":"try { var ne = await IterableNE.createRange(items); }\ncatch (ArgumentException ex) when (ex.Message.Contains(\"empty sequence\"))\n{\n    // decide: default value, Option.None, or rethrow with context\n}","preventionTips":["Never assume async sources are non-empty; always probe IsEmpty first","Prefer Iterable<A> when emptiness is a legitimate domain state","Materialize with a Count/Any check before building non-empty types","Add tests with empty inputs for all IterableNE constructions","Encode emptiness as Option<IterableNE<A>> at API boundaries"],"tags":["empty-sequence","non-empty-invariant","argument-exception","csharp"],"backgroundTag":"empty-result-set","analyzedSha":"2f0e3628242889774d4141960a35671a0280051f","analyzedAt":"2026-09-15T03:31:55.716Z","contentChangedAt":"2026-09-15T03:31:55.716Z","schemaVersion":2},"datasetVersion":"2026-09-16T09:17:16.951Z"}