C to Rust translator

Related tags

Utilities corrode
Overview

Corrode: Automatic semantics-preserving translation from C to Rust

Build Status

This program reads a C source file and prints an equivalent module in Rust syntax. It's intended for partial automation of migrating legacy code that was implemented in C. This tool does not fully automate the job because its output is only as safe as the input was; you should clean up the output afterward to use Rust features and idioms where appropriate.

Quick Start

As of now, there are no pre-built binaries available, so you need to build the project yourself, but don't let that scare you away; clone the project, cd into it and follow along :)

Windows

If you're using Windows, start by running fixGitSymlinksForWindows.bat as admin (this is necessary for Git to create symlinks).

Cabal

Ensure that you have GHC and the cabal-install tool installed by following the directions on haskell.org. You'll also need to have the happy and alex tools available in order to build corrode: you can install them with the cabal-install tool, as well. Once you have installed the cabal-install tool, you can build corrode by navigating to the corrode directory, installing the happy and alex tools, and then building and installing the corrode package:

cabal install happy
cabal install alex
cabal install

This puts the corrode executable in ~/.cabal/bin, so ensure that that location is in your $PATH.

Alternate instructions: Stack

Alternately, you can use the Haskell Stack tool for Haskell development. If you don't have it, head over to their website and follow the instructions for installing it on your machine.

Install the Glasgow Haskell Compiler using stack setup. You can skip this step if you already have a version of GHC installed on your system. You can then build and install corrode by navigating to the corrode directory and running:

stack install

Stack will build and install corrode to ~/.local/bin. For ease of use, make sure that directory is in your $PATH.

To experiment with the project itself, you can build it using

stack build

then run the executable:

stack exec -- corrode -Wall filename.c -I/usr/local/include -lm

Usage

There are two ways to use Corrode. You can simply generate a .rs file from the C source, or you can do this and compile in one step.

Generating Rust source

You can now run corrode, giving it any options that gcc would accept.

corrode -Wall filename.c -I/usr/local/include -lm

It will only use the options that are relevant to the C pre-processor, like -I or -D, but since it accepts and ignores any other options, you can usually get going just by changing gcc to corrode in the gcc invocation you've been using.

Unlike a real C compiler, Corrode does not produce an object file or executable! Instead, if you ask it to process filename.c, it generates equivalent Rust source code in filename.rs. If you do want object code, there is a script to help with that.

Codegen with compilation

You can either invoke rustc on Corrode's output yourself (or import it into a Rust project), or use the scripts/corrode-cc tool in place of gcc to compile and link. In many build systems, such as make, you can simply set CC=corrode-cc without modification.

Design principles

The overarching goal of Corrode is to preserve the original properties of the source program as much as possible: behavior, ABI compatibility, and maintainability. We expect the output of Corrode to be used to replace the original C, not just as an intermediate step in a compiler toolchain.

Corrode aims to produce Rust source code which behaves exactly the same way that the original C source behaved, if the input is free of undefined and implementation-defined behavior. In the presence of undefined behavior, we've tried to pick a behavior that isn't too surprising. For example, if a signed addition might overflow (which is undefined behavior in C), Corrode just translates it to Rust's + operator, which panics on overflow in debug builds.

The compiled Rust source in turn will be ABI-compatible with the original C. If you compile Corrode-generated Rust to a .o file, you can link to it exactly as if it were generated from the original C. Every function that Corrode generates with be annotated with the extern "C" modifier.

At the same time, Corrode should produce code which is recognizably structured like the original, so that the output is as maintainable as the original. Every statement and every expression should be represented in the output—in the same order, where possible. If a programmer went to the trouble to put something in, we usually want it in the translated output; if it's not necessary, we can let the Rust compiler warn about it.

If either behavior or ABI is not preserved, we consider that a bug in Corrode. However, it is not always possible to preserve the structure of the original code, so we do the best that we can.

Testing

So far, Corrode has primarily been tested by generating random C programs using csmith, fixing Corrode until it can handle all syntax used in that particular program, and verifying that the resulting Rust module compiles without errors.

Verifying that the translated output is equivalent to the input is not trivial. One approach I think is worth trying is to use the Galois Software Analysis Workbench to prove that the LLVM bitcode generated from clang on a C source file is equivalent to the LLVM bitcode generated from rustc on a Rust source file from Corrode. SAW uses a symbolic simulator over LLVM bitcode to extract logical formulas representing the behavior of each function, and then uses an SMT solver to prove equivalence between pairs of formulas. Generating large numbers of random C programs using csmith and then proving the translation results equivalent for each one should give pretty good confidence in the implementation.

Because the project is still in its early phases, it is not yet possible to translate most real C programs or libraries. But if you have one you particularly want to try out, I'd love to get pull requests implementing more of C!

Contributing

If this seems cool and you'd like to help complete it, welcome! There are quite a few fundamental pieces of the C standard which are not yet implemented. I'd love to chat with you if you're not quite sure how to get started! You can e-mail me at mailto:[email protected].

What Corrode is not

A Rust module that exactly captures the semantics of a C source file is a Rust module that doesn't look very much like Rust. ;-) I would like to build a companion tool which rewrites parts of a valid Rust program in ways that have the same result but make use of Rust idioms. I think it should be separate from this tool because I expect it to be useful for other folks, not just users of Corrode. I propose to call that program "idiomatic", and I think it should be written in Rust using the Rust AST from syntex_syntax.

Comments
  • Adding partial initialization of structs

    Adding partial initialization of structs

    To the best of my understanding of C99, this implements partial initialization (previous discussion), dealing with zeroing and out of order fields.

    struct grade {
      float percentage;
      int failing;
    };
    struct student {
      struct student *friends;
      int age;
      struct grade marks;
    };
    
    void f() {
      struct student s;
      s = (struct student) { };
      s = (struct student) { .age = 9 };
      s = (struct student) { .age = 9, { 0.45, 1 } };
      s = (struct student) { .age = 9, { .percentage = 0.45, .failing = 1 } };
      s = (struct student) { 0, 9, { 0.45, 1 } };
      s = (struct student) { .marks = { 0.45, 1 }, .age = 9 };
    }
    

    compiles to

    #[derive(Clone, Copy)]
    #[repr(C)]
    pub struct grade {
        pub percentage : f32,
        pub failing : i32,
    }
    
    #[derive(Clone, Copy)]
    #[repr(C)]
    pub struct student {
        pub friends : *mut student,
        pub age : i32,
        pub marks : grade,
    }
    
    #[no_mangle]
    pub unsafe fn f() {
        let mut s : student;
        s = student {
                friends: 0 as (*mut student),
                age: 0i32,
                marks: grade { percentage: 0f32, failing: 0i32 }
            };
        s = student {
                friends: 0 as (*mut student),
                age: 9i32,
                marks: grade { percentage: 0f32, failing: 0i32 }
            };
        s = student {
                friends: 0 as (*mut student),
                age: 9i32,
                marks: grade { percentage: 0.45f64 as (f32), failing: 1i32 }
            };
        s = student {
                friends: 0 as (*mut student),
                age: 9i32,
                marks: grade { percentage: 0.45f64 as (f32), failing: 1i32 }
            };
        s = student {
                friends: 0i32 as (*mut student),
                age: 9i32,
                marks: grade { percentage: 0.45f64 as (f32), failing: 1i32 }
            };
        s = student {
                friends: 0 as (*mut student),
                age: 9i32,
                marks: grade { percentage: 0.45f64 as (f32), failing: 1i32 }
            };
    }
    

    And code that has too many initializers or designators that do not correspond to fields or non-member designators is dealt with via badSource.

    One thing that isn't clear to me from the C99 spec on initialization (6.7.8) - when does it make sense to have multiple designators for a given initializer? Seems like point 18 addresses this, and I think this means I am rejecting valid code, since I currently assume that an initializer can have at most one designator (and it must be a member designator)...

    opened by harpocrates 24
  • implement goto in C

    implement goto in C

    extern int printf (const char *format, ...);
    extern int getchar(void);
    
    int main(void)
    {
        int n=0;
        printf("input a string :\n");
    loop: if(getchar()!='\n')
          {
              n++;
              goto loop;
          }
          printf("length is %d\n",n);
    }
    
    
    corrode: ("goto.c": line 10): Corrode doesn't handle this yet:
        loop:
            if (getchar() != '\n')
            {
                n++;
                goto loop;
            }
    
    
    opened by meagon 18
  • implement do-while loops

    implement do-while loops

    The CWhile constructor of CExpression is currently only translated if its Bool flag is False, meaning this is a regular while-loop which tests the loop condition before entering the loop.

    If that flag is True, then we need a different translation plan. Since Rust doesn't have do-while loops, we'll have to translate these like this:

    loop {
        ...
        if !cond { break; }
    }
    

    But like for loops, it's a little trickier than that if the loop contains any continue statements. The same strategy we use on for loops should work here, though:

    'breakTo: loop {
        'continueTo: loop {
            ...
            break;
        }
        if !cond { break; }
    }
    

    Like with for loops, break and continue statements should be translated to break 'breakTo and break 'continueTo, respectively.

    easy 
    opened by jameysharp 16
  • does not build on Windows

    does not build on Windows

    I get the following error running cabal install or stack install in the project root:

    cabal install output:

    Resolving dependencies...
    Configuring corrode-0.1.0.0...
    Building corrode-0.1.0.0...
    Failed to install corrode-0.1.0.0
    Build log ( C:\Users\crame\AppData\Roaming\cabal\logs\corrode-0.1.0.0.log ):
    Building corrode-0.1.0.0...
    Preprocessing library corrode-0.1.0.0...
    
    src\Language\Rust\Corrode\C.lhs:1:1: error:
        File name does not match module name:
        Saw: `Main'
        Expected: `Language.Rust.Corrode.C'
    cabal: Leaving directory '.'
    cabal: Error: some packages failed to install:
    corrode-0.1.0.0
    

    stack install output:

    corrode-0.1.0.0: build
    Preprocessing library corrode-0.1.0.0...
    
    C:\Users\crame\rustiness\corrode\src\Language\Rust\Corrode\C.lhs:1:1:
        File name does not match module name:
        Saw: `Main'
        Expected: `Language.Rust.Corrode.C'
    
    --  While building package corrode-0.1.0.0 using:
          C:\Users\crame\AppData\Roaming\stack\setup-exe-cache\x86_64-windows\setup-Simple-Cabal-1.22.5.0-ghc-7.10.3.exe --builddir=.stack-work\dist\2672c1f3 build lib:corrode exe:corrode --ghc-options " -ddump-hi -ddump-to-file"
        Process exited with code: ExitFailure 1
    

    This occurs on 64 bit Windows after a fresh install of the Haskell Platform.

    opened by cramertj 13
  • implement enum

    implement enum

    C's enum types are pretty easy to translate except for the fact that C allows arbitrary integer values to be used where an enum variant is expected. Rust's enums don't allow that (as far as I know).

    So step one is: Figure out what we can translate C enums to in Rust that will allow valid C programs to be translated (even if they use values outside the range of the enum), while ideally preserving all uses of the names of the enum variants.

    opened by jameysharp 12
  • Break not inserted into for loop

    Break not inserted into for loop

    This simple code does not produce the correct output

        for (int i = 0;i < num_clusters;++i) {
            if (clusters[i] == best_index) {
                fake_memmove(&clusters[i],
                        &clusters[i+1],
                        (num_clusters - i- 1)* sizeof(clusters[0]));
                break;
            }
        }
    

    the break is omitted from the output code

        let mut i : i32 = 0i32;
        'loop1: loop {
            if i < num_clusters {
                if clusters[i as (usize)] == best_index {
                    fake_memmove(
                        &mut clusters[
                                 i as (usize)
                             ] as (*mut u32) as (*mut ::std::os::raw::c_void),
                        &mut clusters[
                                 (i + 1i32) as (usize)
                             ] as (*mut u32) as (*mut ::std::os::raw::c_void),
                        ((num_clusters - i - 1i32) as (usize)).wrapping_mul(
                            ::std::mem::size_of::<u32>()
                        )
                    );
                } else {
                    i = i + 1;
                    continue 'loop1;
                }
            } else {
                break 'loop1;
            }
        }
    

    A fix would be appreciated: I've been using corrode to translate the brotli encoder and I'm worried I've hit this situation more than once

    opened by danielrh 7
  • Can't translate basic C programs?

    Can't translate basic C programs?

    Everything that I try and translate seems to result it pub unsafe fn main() -> i32 { 0i32 } or something similar (depending on the types used in the c program). Why is this?

    opened by garethellis0 7
  • implement sizeof/alignof for expressions

    implement sizeof/alignof for expressions

    The CSizeofExpr and CAlignofExpr constructors of CExpression should be translated almost identically to the CSizeofType and CAlignofType constructors, respectively, except that the expression needs to be translated using interpretExpr.

    However, I'm not sure about the exact translation. There are two possibilities:

    1. If the expression is supposed to have its side effects evaluated, then we should pass a borrow of the resulting expression to std::mem::size_of_val.
    2. Otherwise, if side effects are not supposed to be evaluated, we should just use the resultType from translating the expression, throwing away the expression itself, and proceed just like CSizeofType/CAlignofType.

    Before trying to implement this, we need a citation to C99 or C11 which clarifies whether the expression should actually be evaluated.

    easy 
    opened by jameysharp 7
  • __builtin_memcpy_chk

    __builtin_memcpy_chk

    Clang will convert some instances of calls to memcpy to __builtin_memcpy_chk.

    I believe that passing -fno-builtin along should address this, but I'm not sure.

    This results in an error like:

    ("rectset.c": line 50): illegal undefined variable; check whether a real C compiler
        accepts this:
        __builtin___memcpy_chk
    

    from this C:

      memcpy(rects, trs->rects, n * sizeof(trs->rects[0]));
    
    opened by waywardmonkeys 6
  • Translate __FUNCTION__

    Translate __FUNCTION__

    Now that I can at least partially read Haskell, I'm going to try out a (potentially) easy first change: Translate __FUNCTION__. It's currently regarded as badSource:

    ("shared_types_gen.h": line 19): illegal undefined variable; check whether a real C compiler accepts this:
        __FUNCTION__
    

    Would it be correct and appropriate to add __FUNCTION__ to getSymbolIdent's list of builtin symbols?

    Properly translating this to Rust depends on rust-lang/rfcs/pull/1719, but for now, I could look up the current function name in the symbol environment.

    I could then follow up by translating __FILE__ and __LINE__ to Rust's file! and line! macros respectively, which is arguably slightly simpler, but __FUNCTION__ is first in my sights.

    opened by jdub 6
  • configure travis-ci

    configure travis-ci

    • https://docs.travis-ci.com/user/languages/haskell
    • https://ghc.haskell.org/trac/ghc/wiki/Travis

    probably test against 8.x and 7.10 so that things like #39 would get caught sooner

    opened by seanjensengrey 6
  • Build failed

    Build failed

    src/Language/Rust/AST.hs:29:36: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 29 | pPrint (Lifetime s) = text "'" <> text s | ^^

    src/Language/Rust/AST.hs:89:32: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 89 | pPrint (Stmt e) = pPrint e <> text ";" | ^^

    src/Language/Rust/AST.hs:94:11: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 94 | ] <> text ";" | ^^

    src/Language/Rust/AST.hs:96:21: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 96 | [ text "#[" <> text attr <> text "]" | Attribute attr <- attrs ] ++ [pPrint k] | ^^

    src/Language/Rust/AST.hs:96:34: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 96 | [ text "#[" <> text attr <> text "]" | Attribute attr <- attrs ] ++ [pPrint k] | ^^

    src/Language/Rust/AST.hs:112:21: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 112 | [ text "#[" <> text attr <> text "]" | Attribute attr <- attrs ] ++ | ^^ src/Language/Rust/AST.hs:112:34: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 112 | [ text "#[" <> text attr <> text "]" | Attribute attr <- attrs ] ++ | ^^
    src/Language/Rust/AST.hs:113:66: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 113 | [(if vis == Public then zeroWidthText "pub " else empty) <> pPrint k] | ^^ src/Language/Rust/AST.hs:136:11: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 136 | [ hsep (map pPrint attrs) <+> text "fn" <+> text nm <> text "(" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    src/Language/Rust/AST.hs:136:61: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 136 | [ hsep (map pPrint attrs) <+> text "fn" <+> text nm <> text "(" | ^^ src/Language/Rust/AST.hs:145:11: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 145 | ] <> text ";" | ^^
    src/Language/Rust/AST.hs:148:24: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 148 | nest 4 (vcat [ text "pub" <+> text field <+> text ":" <+> pPrint ty <> text "," | (field, ty) <- fields ]) $+$ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    src/Language/Rust/AST.hs:148:77: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 148 | nest 4 (vcat [ text "pub" <+> text field <+> text ":" <+> pPrint ty <> text "," | (field, ty) <- fields ]) $+$ | ^^
    src/Language/Rust/AST.hs:155:25: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 155 | pPrint (Use path) = text "use" <+> text path <> text ";" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Language/Rust/AST.hs:155:50: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 155 | pPrint (Use path) = text "use" <+> text path <> text ";" | ^^
    src/Language/Rust/AST.hs:158:36: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 158 | nest 4 (vcat [ pPrint enum <> text "," | enum <- enums ]) $+$ | ^^ src/Language/Rust/AST.hs:164:32: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 164 | , text "clone" <> parens (text "&self") | ^^
    src/Language/Rust/AST.hs:180:11: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 180 | [ text "fn" <+> text nm <> text "(" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Language/Rust/AST.hs:180:33: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 180 | [ text "fn" <+> text nm <> text "(" | ^^
    src/Language/Rust/AST.hs:185:11: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 185 | , text ")" <+> (if ret == TypeName "()" then empty else text "->" <+> pPrint ret) <> text ";" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Language/Rust/AST.hs:185:91: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 185 | , text ")" <+> (if ret == TypeName "()" then empty else text "->" <+> pPrint ret) <> text ";" | ^^ src/Language/Rust/AST.hs:193:11: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 193 | ] <> text ";" | ^^
    src/Language/Rust/AST.hs:305:62: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 305 | go pos _ (Index arr idx) = cat [go (left pos) 13 arr <> text "[", nest 4 (go RightExpr 0 idx), text "]"] | ^^
    src/Language/Rust/AST.hs:311:40: error: Precedence parsing error cannot mix ‘Prelude.<>’ [infixr 6] and ‘<+>’ [infixl 6] in the same infix expression | 311 | go _ _ (RepeatArray el size) = text "[" <> go RightExpr 0 el <> text ";" <+> go RightExpr 0 size <> text "]" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Language/Rust/AST.hs:311:40: error: Precedence parsing error cannot mix ‘<+>’ [infixl 6] and ‘Prelude.<>’ [infixr 6] in the same infix expression | 311 | go _ _ (RepeatArray el size) = text "[" <> go RightExpr 0 el <> text ";" <+> go RightExpr 0 size <> text "]" | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    src/Language/Rust/AST.hs:311:49: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 311 | go _ _ (RepeatArray el size) = text "[" <> go RightExpr 0 el <> text ";" <+> go RightExpr 0 size <> text "]" | ^^
    src/Language/Rust/AST.hs:311:70: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 311 | go _ _ (RepeatArray el size) = text "[" <> go RightExpr 0 el <> text ";" <+> go RightExpr 0 size <> text "]" | ^^
    src/Language/Rust/AST.hs:311:106: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 311 | go _ _ (RepeatArray el size) = text "[" <> go RightExpr 0 el <> text ";" <+> go RightExpr 0 size <> text "]" | ^^ src/Language/Rust/AST.hs:314:47: error: Precedence parsing error cannot mix ‘Prelude.<>’ [infixr 6] and ‘<+>’ [infixl 6] in the same infix expression | 314 | : punctuate (text ",") ([ nest 4 (text name <> text ":" <+> go RightExpr 0 val) | (name, val) <- fields ] ++ maybe [] (\b -> [ text ".." <> go RightExpr 0 b ]) base) | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ src/Language/Rust/AST.hs:314:57: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 314 | : punctuate (text ",") ([ nest 4 (text name <> text ":" <+> go RightExpr 0 val) | (name, val) <- fields ] ++ maybe [] (\b -> [ text ".." <> go RightExpr 0 b ]) base) | ^^ src/Language/Rust/AST.hs:314:150: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 314 | : punctuate (text ",") ([ nest 4 (text name <> text ":" <+> go RightExpr 0 val) | (name, val) <- fields ] ++ maybe [] (\b -> [ text ".." <> go RightExpr 0 b ]) base) | ^^ src/Language/Rust/AST.hs:318:34: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 318 | ( go (left pos) 14 f <> text "(" | ^^ src/Language/Rust/AST.hs:323:37: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 323 | ( go (left pos) 13 self <> text "." <> pPrint f <> text "(" | ^^

    src/Language/Rust/AST.hs:323:49: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 323 | ( go (left pos) 13 self <> text "." <> pPrint f <> text "(" | ^^ src/Language/Rust/AST.hs:323:61: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 323 | ( go (left pos) 13 self <> text "." <> pPrint f <> text "(" | ^^
    src/Language/Rust/AST.hs:329:16: error: Precedence parsing error cannot mix ‘Prelude.<>’ [infixr 6] and ‘<+>’ [infixl 6] in the same infix expression | 329 | in text "|" <> args' <> text "|" <+> go RightExpr 0 body | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    src/Language/Rust/AST.hs:329:25: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 329 | in text "|" <> args' <> text "|" <+> go RightExpr 0 body | ^^
    src/Language/Rust/AST.hs:329:34: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 329 | in text "|" <> args' <> text "|" <+> go RightExpr 0 body | ^^
    src/Language/Rust/AST.hs:330:82: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 330 | go pos d (Member obj field) = maybeParens (d > 13) (go (left pos) 13 obj <> text "." <> pPrint field) | ^^

    src/Language/Rust/AST.hs:330:94: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 330 | go pos d (Member obj field) = maybeParens (d > 13) (go (left pos) 13 obj <> text "." <> pPrint field) | ^^ src/Language/Rust/AST.hs:378:57: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 378 | optLabel = maybe empty (\ label -> pPrint label <> text ":") | ^^ src/Language/Rust/AST.hs:380:55: error: Ambiguous occurrence ‘<>’ It could refer to either ‘Prelude.<>’, imported from ‘Prelude’ at src/Language/Rust/AST.hs:1:8-24 (and originally defined in ‘GHC.Base’) or ‘Text.PrettyPrint.HughesPJClass.<>’, imported from ‘Text.PrettyPrint.HughesPJClass’ at src/Language/Rust/AST.hs:5:1-37 (and originally defined in ‘Text.PrettyPrint.HughesPJ’) | 380 | unary d n op e = maybeParens (d > n) (text op <> go RightExpr n e) | ^^ cabal: Leaving directory '.' cabal: Error: some packages failed to install: corrode-0.1.0.0-7JByiBhjcJ4AiUKajiokjH failed during the building phase. The exception was: ExitFailure 1

    opened by fish4terrisa-MSDSM 1
  • FTBFS: fails to build on OpenSUSE/Tumbleweed

    FTBFS: fails to build on OpenSUSE/Tumbleweed

    Hi,

    I am trying to build corrode on OpenSUSE/Tumbleweed (constantly updated) with these packages installed:

    [email protected] (master *%)$ rpm -qa cabal\* ghc\*|sort
    cabal-install-3.2.0.0-3.3.x86_64
    ghc-array-devel-0.5.4.0-3.1.x86_64
    ghc-array-0.5.4.0-3.1.x86_64
    ghc-base-devel-4.14.1.0-3.1.x86_64
    ghc-base-4.14.1.0-3.1.x86_64
    ghc-binary-devel-0.8.8.0-3.1.x86_64
    ghc-binary-0.8.8.0-3.1.x86_64
    ghc-bytestring-devel-0.10.10.0-3.1.x86_64
    ghc-bytestring-0.10.10.0-3.1.x86_64
    ghc-Cabal-devel-3.2.0.0-3.1.x86_64
    ghc-Cabal-3.2.0.0-3.1.x86_64
    ghc-compiler-8.10.2-3.1.x86_64
    ghc-containers-devel-0.6.2.1-3.1.x86_64
    ghc-containers-0.6.2.1-3.1.x86_64
    ghc-deepseq-devel-1.4.4.0-3.1.x86_64
    ghc-deepseq-1.4.4.0-3.1.x86_64
    ghc-directory-devel-1.3.6.0-3.1.x86_64
    ghc-directory-1.3.6.0-3.1.x86_64
    ghc-exceptions-devel-0.10.4-3.1.x86_64
    ghc-exceptions-0.10.4-3.1.x86_64
    ghc-filepath-devel-1.4.2.1-3.1.x86_64
    ghc-filepath-1.4.2.1-3.1.x86_64
    ghc-ghc-boot-devel-8.10.2-3.1.x86_64
    ghc-ghc-boot-th-devel-8.10.2-3.1.x86_64
    ghc-ghc-boot-th-8.10.2-3.1.x86_64
    ghc-ghc-boot-8.10.2-3.1.x86_64
    ghc-ghc-compact-devel-0.1.0.0-3.1.x86_64
    ghc-ghc-compact-0.1.0.0-3.1.x86_64
    ghc-ghc-devel-8.10.2-3.1.x86_64
    ghc-ghc-heap-devel-8.10.2-3.1.x86_64
    ghc-ghc-heap-8.10.2-3.1.x86_64
    ghc-ghci-devel-8.10.2-3.1.x86_64
    ghc-ghci-8.10.2-3.1.x86_64
    ghc-ghc-8.10.2-3.1.x86_64
    ghc-haskeline-devel-0.8.0.1-3.1.x86_64
    ghc-haskeline-0.8.0.1-3.1.x86_64
    ghc-hpc-devel-0.6.1.0-3.1.x86_64
    ghc-hpc-0.6.1.0-3.1.x86_64
    ghc-language-c-0.9-1.2.x86_64
    ghc-libiserv-devel-8.10.2-3.1.x86_64
    ghc-libiserv-8.10.2-3.1.x86_64
    ghc-libraries-8.10.2-3.1.x86_64
    ghc-mtl-devel-2.2.2-3.1.x86_64
    ghc-mtl-2.2.2-3.1.x86_64
    ghc-parsec-devel-3.1.14.0-3.1.x86_64
    ghc-parsec-3.1.14.0-3.1.x86_64
    ghc-pretty-devel-1.1.3.6-3.1.x86_64
    ghc-pretty-1.1.3.6-3.1.x86_64
    ghc-process-devel-1.6.9.0-3.1.x86_64
    ghc-process-1.6.9.0-3.1.x86_64
    ghc-stm-devel-2.5.0.0-3.1.x86_64
    ghc-stm-2.5.0.0-3.1.x86_64
    ghc-syb-0.7.1-4.2.x86_64
    ghc-template-haskell-devel-2.16.0.0-3.1.x86_64
    ghc-template-haskell-2.16.0.0-3.1.x86_64
    ghc-terminfo-devel-0.4.1.4-3.1.x86_64
    ghc-terminfo-0.4.1.4-3.1.x86_64
    ghc-text-devel-1.2.3.2-3.1.x86_64
    ghc-text-1.2.3.2-3.1.x86_64
    ghc-time-devel-1.9.3-3.1.x86_64
    ghc-time-1.9.3-3.1.x86_64
    ghc-transformers-devel-0.5.6.2-3.1.x86_64
    ghc-transformers-0.5.6.2-3.1.x86_64
    ghc-unix-devel-2.7.2.2-3.1.x86_64
    ghc-unix-2.7.2.2-3.1.x86_64
    ghc-xhtml-devel-3000.2.2.1-3.1.x86_64
    ghc-xhtml-3000.2.2.1-3.1.x86_64
    ghc-8.10.2-3.1.x86_64
    [email protected] (master *%)$ 
    

    I had to also install markdown-unlit directly via cabal install (I have version 0.5.0), but when I try to run cabal build (with few changes in https://github.com/mcepl/corrode/tree/build_opensuse) I get tons of erros and build fails.

    Complete stdout/stderr of cabal build --verbose

    opened by mcepl 0
  • Test improvements

    Test improvements

    Hi @jameysharp ,

    I find this project interesting. Would you be willing to include these continuous integration and Docker image improvements?

    This pull request considers PRs #147, #145 and #161: if you merge this PR without squashing or rebasing, those shall get closed automatically by GitHub.


    I see there are some useful open pull requests, though there has not been much activity in the master branch in the last couple of years. It would be nice to get most of those changes reviewed and merged to a common branch that can be based upon. I started such an effort in the following branch:

    https://github.com/lucafavatella/corrode/commits/develop-2019

    (Deletion of that ^^^ branch planned for end of year 2019.)

    I started from non-invasive tests (reflected in this PR), I may in the following months continue with including changes in other PRs. Though before doing so I wanted to check the activity in this repo hence this PR.

    opened by lucafavatella 0
  • Ignore/support __builtin_ functions

    Ignore/support __builtin_ functions

    __builtin functions currently aren't accepted by corrode

    On macos:

    ("/usr/include/math.h": line 205): illegal undefined variable; check whether a real C compiler accepts this:
        __builtin_fabsf
    
    opened by lu-zero 0
  • Suggest to run cabal update

    Suggest to run cabal update

    A good deal of people would install cabal and friends just to have corrode, better add another step so they won't be surprised if they dare to paste the commands and leave it unattended.

    opened by lu-zero 1
Owner
Jamey Sharp
Jamey Sharp
k-mer counter in Rust using the rust-bio and rayon crates

krust is a k-mer counter written in Rust and run from the command line that will output canonical k-mers and their frequency across the records in a f

null 12 Nov 30, 2022
Experimental Rust tool for generating FFI definitions allowing many other languages to call Rust code

Diplomat is an experimental Rust tool for generating FFI definitions allowing many other languages to call Rust code. With Diplomat, you can simply define Rust APIs to be exposed over FFI and get high-level C, C++, and JavaScript bindings automatically!

null 240 Dec 3, 2022
Aws-sdk-rust - AWS SDK for the Rust Programming Language

The AWS SDK for Rust This repo contains the new AWS SDK for Rust (the SDK) and its public roadmap. Please Note: The SDK is currently released as a dev

Amazon Web Services - Labs 2k Dec 2, 2022
Rust + Yew + Axum + Tauri, full-stack Rust development for Desktop apps.

rust-yew-axum-tauri-desktop template Rust + Yew + Axum + Tauri, full-stack Rust development for Desktop apps. Crates frontend: Yew frontend app for de

Jet Li 51 Nov 30, 2022
A lightning fast version of tmux-fingers written in Rust, copy/pasting tmux like vimium/vimperator

tmux-thumbs A lightning fast version of tmux-fingers written in Rust for copy pasting with vimium/vimperator like hints. Usage Press ( prefix + Space

Ferran Basora 583 Nov 25, 2022
A command-line tool collection to assist development written in RUST

dtool dtool is a command-line tool collection to assist development Table of Contents Description Usage Tips Installation Description Now dtool suppor

GB 310 Nov 26, 2022
Rust mid-level IR Abstract Interpreter

MIRAI MIRAI is an abstract interpreter for the Rust compiler's mid-level intermediate representation (MIR). It is intended to become a widely used sta

Facebook Experimental 780 Nov 27, 2022
Migrate C code to Rust

C2Rust helps you migrate C99-compliant code to Rust. The translator (or transpiler) produces unsafe Rust code that closely mirrors the input C code. T

Immunant 2.9k Nov 25, 2022
Astronomical algorithms in Rust

astro-rust Contents API Docs About Usage Contributing References About astro-rust is a library of advanced astronomical algorithms for the Rust progra

Saurav Sachidanand 206 Nov 6, 2022
A Rust library for calculating sun positions

sun A rust port of the JS library suncalc. Install Add the following to your Cargo.toml [dependencies] sun = "0.2" Usage pub fn main() { let unixti

Markus Kohlhase 34 Nov 27, 2022
Macro for Python-esque comprehensions in Rust

Cute Macro for Python-esque list comprehensions in Rust. The c! macro implements list and hashmap comprehensions similar to those found in Python, all

Matt Gathu 303 Nov 22, 2022
Language Integrated Query in Rust.

Linq in Rust Language Integrated Query in Rust (created by declarative macros). Inspired by LINQ in .NET. What's LINQ This project is under developmen

StardustDL 90 Nov 20, 2022
A cross-platform serial port library in Rust.

Introduction serialport-rs is a general-purpose cross-platform serial port library for Rust. It provides a blocking I/O interface and port enumeration

Bryant Mairs 143 Nov 5, 2021
A Rust macro for writing regex pattern matching.

regexm A Rust macro for writing regex pattern matching.

Takayuki Maeda 46 Oct 24, 2022
Simple ray tracer written in Rust

Simple ray tracer written in Rust from scratch I've just finished my first semester at the Faculty of Applied Mathematics and Computer Science at the

Vladislav 189 Oct 30, 2022
A high level diffing library for rust based on diffs

Similar: A Diffing Library Similar is a dependency free crate for Rust that implements different diffing algorithms and high level interfaces for it.

Armin Ronacher 606 Nov 21, 2022
A reactive DOM library for Rust in WASM

maple A VDOM-less web library with fine-grained reactivity. Getting started The recommended build tool is Trunk. Start by adding maple-core to your Ca

Luke Chu 1.8k Dec 2, 2022
A library to compile USDT probes into a Rust library

sonde sonde is a library to compile USDT probes into a Rust library, and to generate a friendly Rust idiomatic API around it. Userland Statically Defi

Ivan Enderlin 39 Oct 12, 2022
transmute-free Rust library to work with the Arrow format

Arrow2: Transmute-free Arrow This repository contains a Rust library to work with the Arrow format. It is a re-write of the official Arrow crate using

Jorge Leitao 660 Dec 2, 2022