hauleth

-module(fizzbuzz).

-export([main/0]).

main() ->
    Types = [
             {3, "Fizz"},
             {5, "Buzz"}
            ],
    io:put_chars(run(100, Types)).

hauleth

{
  "nodes": {
    "devenv": {
      "inputs": {
        "flake-compat": "flake-compat",
        "nix": "nix",
        "nixpkgs": [
          "nixpkgs"
        ],
        "poetry2nix": "poetry2nix",

hauleth

defmodule Langusta.Site.CleanURL do
  defmodule Entry do
    defstruct [
      :url_pattern,
      rules: [],
      raw_rules: [],
      exceptions: [],
      redirections: []
    ]

hauleth

{config, pkgs, ...}: let
  domain = "hauleth.dev";
  mail-domain = "mail.${domain}";
  sieve-data = let
    stalwart-mail = config.services.stalwart-mail.package;
  in pkgs.stdenvNoCC.mkDerivation {
    pname = "stalwart-mail-sieve-data";
    inherit (stalwart-mail) version src;

    dontBuild = true;

hauleth

{
  "nodes": {
    "flake-utils": {
      "inputs": {
        "systems": "systems"
      },
      "locked": {
        "lastModified": 1694529238,
        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
        "owner": "numtide",

hauleth

const std = @import("std");

const Type = std.builtin.Type;

pub fn Templates(comptime entries: anytype) type {
    const type_info = @typeInfo(@TypeOf(entries)).Struct;

    var enum_fields: [type_info.fields.len]Type.EnumField = undefined;

    for (type_info.fields, 0..) |field, idx| {

hauleth

defmodule Mix.Tasks.Man do
  @moduledoc """
  Print documentation for given Elixir term.
  """

  @shortdoc "Show manual for term"

  use Mix.Task

  require IEx.Helpers

hauleth

{
  "nodes": {
    "devenv": {
      "inputs": {
        "flake-compat": "flake-compat",
        "nix": "nix",
        "nixpkgs": "nixpkgs",
        "pre-commit-hooks": "pre-commit-hooks"
      },
      "locked": {

hauleth

all: test

hauleth

defmodule BellmanFord2 do
  @moduledoc """
  The Bellman–Ford algorithm is an algorithm that computes shortest paths from a single
  source vertex to all of the other vertices in a weighted digraph.
  It is capable of handling graphs in which some of the edge weights are negative numbers
  Time complexity: O(VLogV)
  """

  @type distance :: %{Graph.vertex_id() => integer}