Metadata revisions for Grow-1.1.0.3

Package maintainers and Hackage trustees are allowed to edit certain bits of package metadata after a release, without uploading a new tarball. Note that the tarball itself is never changed, just the metadata that is stored separately. For more information about metadata revisions, please refer to the Hackage Metadata Revisions FAQ.

No. Time User Changes
-r3 Sun Jul 13 15:03:59 UTC 2014 MarcCoiffier
  • Changed homepage

    http://coiffier.net/projects/grow.html

-r2 Sun Jul 13 12:01:09 UTC 2014 MarcCoiffier
  • Changed description from

    Grow is a well-defined replacement for Makefiles and the like to build complex
    hierarchies of files with minimal effort.
    
    Like many Makefile-like tools, Grow depends on the notion of
    timestamps to determine whether a file should be recompiled or
    not. Grow is much simpler than those, though, and I might argue way
    easier to use as well.
    
    On startup, Grow will look for a file named "Seed" in the current
    directory, and evaluate the grow expressions contained within.
    
    For example, here is a simple Seed file to compile a single C file
    into an executable.
    
    @
    tee $$arg:in {
       all = ($main:seq "All done !"):in $execs
       execs = hook ld [main] [main.o] :in $objects
       objects = hook cc [main.o] [main.c]
    }
    @
    
    Notice the `hook` function ? It is the Grow primitive that calls an
    external program to perform actual tasks.
    
    In Grow, hooks are expected to only accept files as their arguments,
    so we have to write the wrapper scripts `cc` and `ld` that accept
    arguments in the form "<destination>... <source>...". They are pretty
    trivial to write since they only involve renaming variables and
    swapping arguments.
    
    Here are sample `cc` and `ld` scripts to show you there is nothing
    magical about them :
    
    > #!/bin/bash
    > obj="$1" ; shift ; src="$1"
    > gcc -c "$src" -o "$obj"
    
    > #!/bin/bash
    > bin="$1" ; shift ; obj="$1"
    > gcc "$obj" -o "$bin"
    
    In grow, instead of writing recipes in the configuration, we just declare
    hooks and then write the appropriate wrapper scripts to call compilers with
    the correct flags and arguments.
    to
    Grow is a well-defined replacement for Makefiles and the like to build complex
    hierarchies of files with minimal effort.
    
    Like many Makefile-like tools, Grow depends on the notion of
    timestamps to determine whether a file should be recompiled or
    not. Grow is much simpler than those, though, and I might argue way
    easier to use as well.
    
    On startup, Grow will look for a file named "Seed" in the current
    directory, and evaluate the grow expressions contained within.
    
    For example, here is a simple Seed file to compile a single C file
    into an executable.
    
    > tee $$arg:in {
    >   all = ($main:seq "All done !"):in $execs
    >   execs = hook ld [main] [main.o] :in $objects
    >   objects = hook cc [main.o] [main.c]
    }
    
    Notice the `hook` function ? It is the Grow primitive that calls an
    external program to perform actual tasks.
    
    In Grow, hooks are expected to only accept files as their arguments,
    so we have to write the wrapper scripts `cc` and `ld` that accept
    arguments in the form "<destination>... <source>...". They are pretty
    trivial to write since they only involve renaming variables and
    swapping arguments.
    
    Here are sample `cc` and `ld` scripts to show you there is nothing
    magical about them :
    
    > #!/bin/bash
    > obj="$1" ; shift ; src="$1"
    > gcc -c "$src" -o "$obj"
    
    > #!/bin/bash
    > bin="$1" ; shift ; obj="$1"
    > gcc "$obj" -o "$bin"
    
    In grow, instead of writing recipes in the configuration, we just declare
    hooks and then write the appropriate wrapper scripts to call compilers with
    the correct flags and arguments.

-r1 Sun Jul 13 11:42:39 UTC 2014 MarcCoiffier
  • Changed description from

    Grow is a well-defined replacement for Makefiles and the like to build complex
    hierarchies of files with minimal effort.
    
    Like many Makefile-like tools, Grow depends on the notion of
    timestamps to determine whether a file should be recompiled or
    not. Grow is much simpler than those, though, and I might argue way
    easier to use as well.
    
    On startup, Grow will look for a file named "Seed" in the current
    directory, and evaluate the grow expressions contained within.
    
    For example, here is a simple Seed file to compile a single C file
    into an executable.
    
    > tee $$arg:in {
    >   all = ($main:seq "All done !"):in $execs
    >   execs = hook ld [main] [main.o] :in $objects
    >   objects = hook cc [main.o] [main.c]
    > }
    
    Notice the `hook` function ? It is the Grow primitive that calls an
    external program to perform actual tasks.
    
    In Grow, hooks are expected to only accept files as their arguments,
    so we have to write the wrapper scripts `cc` and `ld` that accept
    arguments in the form "<destination>... <source>...". They are pretty
    trivial to write since they only involve renaming variables and
    swapping arguments.
    
    Here are sample `cc` and `ld` scripts to show you there is nothing
    magical about them :
    
    > #!/bin/bash
    > obj="$1" ; shift ; src="$1"
    > gcc -c "$src" -o "$obj"
    
    > #!/bin/bash
    > bin="$1" ; shift ; obj="$1"
    > gcc "$obj" -o "$bin"
    
    In grow, instead of writing recipes in the configuration, we just declare
    hooks and then write the appropriate wrapper scripts to call compilers with
    the correct flags and arguments.
    to
    Grow is a well-defined replacement for Makefiles and the like to build complex
    hierarchies of files with minimal effort.
    
    Like many Makefile-like tools, Grow depends on the notion of
    timestamps to determine whether a file should be recompiled or
    not. Grow is much simpler than those, though, and I might argue way
    easier to use as well.
    
    On startup, Grow will look for a file named "Seed" in the current
    directory, and evaluate the grow expressions contained within.
    
    For example, here is a simple Seed file to compile a single C file
    into an executable.
    
    @
    tee $$arg:in {
    &#x20;  all = ($main:seq "All done !"):in $execs
    &#x20;  execs = hook ld [main] [main.o] :in $objects
    &#x20;  objects = hook cc [main.o] [main.c]
    }
    @
    
    Notice the `hook` function ? It is the Grow primitive that calls an
    external program to perform actual tasks.
    
    In Grow, hooks are expected to only accept files as their arguments,
    so we have to write the wrapper scripts `cc` and `ld` that accept
    arguments in the form "<destination>... <source>...". They are pretty
    trivial to write since they only involve renaming variables and
    swapping arguments.
    
    Here are sample `cc` and `ld` scripts to show you there is nothing
    magical about them :
    
    > #!/bin/bash
    > obj="$1" ; shift ; src="$1"
    > gcc -c "$src" -o "$obj"
    
    > #!/bin/bash
    > bin="$1" ; shift ; obj="$1"
    > gcc "$obj" -o "$bin"
    
    In grow, instead of writing recipes in the configuration, we just declare
    hooks and then write the appropriate wrapper scripts to call compilers with
    the correct flags and arguments.

-r0 Sun Jul 13 11:32:13 UTC 2014 MarcCoiffier