Importing Elixir libraries to Erlang env

Hello guys,
I need some help with loading my elixir library in erlang env this what I have

start()-> 
	code:add_path("/usr/local/elixir/lib/elixir/ebin/"),
    code:add_path("../build/dev/lib/local_welfare/ebin/"),
    application:start(compiler),
    application:start(elixir),
	io:format("erlang to elixir interface started ~n",[]).

(name@localhost)2> 'Elixir.'
'Elixir.Kernel'              'Elixir.Macro.Env'           
'Elixir.String.Tokenizer'    'Elixir.System'              

The start function loads elixir libraries ,but I can only access few modules on terminal any idea why ,
I am failing to access other modules or libraries

The shell can only give TAB expansions on the modules it knows about and has used, it will not go out and try to find all modules which start with Elixir.. You need to call them explicitly first.

2 Likes

@josevalim any ideas or work around on this

I’m not really into Erlang, but before your comment I have checked it and I got full list of modules without using any …

5> 'Elixir.'
'Elixir.Access'                              
'Elixir.Agent'                               
'Elixir.Agent.Server'                        
'Elixir.Application'                         
'Elixir.ArgumentError'                       
'Elixir.ArithmeticError'                     
'Elixir.Atom'                                
'Elixir.BadArityError'                       
'Elixir.BadBooleanError'                     
'Elixir.BadFunctionError'                    
'Elixir.BadMapError'                         
'Elixir.BadStructError'                      
'Elixir.Base'                                
'Elixir.Behaviour'                           
'Elixir.Bitwise'                             
'Elixir.Calendar'                            
'Elixir.Calendar.ISO'                        
'Elixir.Calendar.TimeZoneDatabase'           
'Elixir.Calendar.UTCOnlyTimeZoneDatabase'    
'Elixir.CaseClauseError'                     
'Elixir.Code'                                
'Elixir.Code.Formatter'                      
'Elixir.Code.Identifier'                     
'Elixir.Code.LoadError'                      
'Elixir.Code.Typespec'                       
'Elixir.Collectable'                         
'Elixir.Collectable.BitString'               
'Elixir.Collectable.File.Stream'             
'Elixir.Collectable.HashDict'                
'Elixir.Collectable.HashSet'                 
'Elixir.Collectable.IO.Stream'               
'Elixir.Collectable.List'                    
'Elixir.Collectable.Map'                     
'Elixir.Collectable.MapSet'                  
'Elixir.CompileError'                        
'Elixir.CondClauseError'                     
'Elixir.Config'                              
'Elixir.Config.Provider'                     
'Elixir.Config.Reader'                       
'Elixir.Date'                                
'Elixir.Date.Range'                          
'Elixir.DateTime'                            
'Elixir.Dict'                                
'Elixir.DynamicSupervisor'                   
'Elixir.Enum'                                
'Elixir.Enum.EmptyError'                     
'Elixir.Enum.OutOfBoundsError'               
'Elixir.Enumerable'                           
'Elixir.Enumerable.Date.Range'               
'Elixir.Enumerable.File.Stream'              
'Elixir.Enumerable.Function'                 
'Elixir.Enumerable.GenEvent.Stream'          
'Elixir.Enumerable.HashDict'                 
'Elixir.Enumerable.HashSet'                  
'Elixir.Enumerable.IO.Stream'                
'Elixir.Enumerable.List'                     
'Elixir.Enumerable.Map'                      
'Elixir.Enumerable.MapSet'                   
'Elixir.Enumerable.Range'                    
'Elixir.Enumerable.Stream'                   
'Elixir.ErlangError'                         
'Elixir.Exception'                           
'Elixir.File'                                
'Elixir.File.CopyError'                      
'Elixir.File.Error'                          
'Elixir.File.LinkError'                      
'Elixir.File.RenameError'                    
'Elixir.File.Stat'                           
'Elixir.File.Stream'                         
'Elixir.Float'                               
'Elixir.Function'                            
'Elixir.FunctionClauseError'                 
'Elixir.GenEvent'                            
'Elixir.GenEvent.Stream'                     
'Elixir.GenServer'                           
'Elixir.HashDict'                            
'Elixir.HashSet'                             
'Elixir.IO'                                  
'Elixir.IO.ANSI'                             
'Elixir.IO.ANSI.Docs'                        
'Elixir.IO.ANSI.Sequence'                    
'Elixir.IO.Stream'                           
'Elixir.IO.StreamError'                      
'Elixir.Inspect'                             
'Elixir.Inspect.Algebra'                     
'Elixir.Inspect.Any'                         
'Elixir.Inspect.Atom'                        
'Elixir.Inspect.BitString'                   
'Elixir.Inspect.Date'                        
'Elixir.Inspect.Date.Range'                  
'Elixir.Inspect.DateTime'                    
'Elixir.Inspect.Error'                       
'Elixir.Inspect.Float'                       
'Elixir.Inspect.Function'                    
'Elixir.Inspect.HashDict'                    
'Elixir.Inspect.HashSet'                     
'Elixir.Inspect.Integer'                     
'Elixir.Inspect.List'                        
'Elixir.Inspect.Macro.Env'                   
'Elixir.Inspect.Map'                         
'Elixir.Inspect.MapSet'                      
'Elixir.Inspect.NaiveDateTime'               
'Elixir.Inspect.Opts'                        
'Elixir.Inspect.PID'                         
'Elixir.Inspect.Port'                        
'Elixir.Inspect.Range'                       
'Elixir.Inspect.Reference'                   
'Elixir.Inspect.Regex'                       
'Elixir.Inspect.Stream'                      
'Elixir.Inspect.Time'                        
'Elixir.Inspect.Tuple'                       
'Elixir.Inspect.Version'                     
'Elixir.Inspect.Version.Requirement'         
'Elixir.Integer'                             
'Elixir.Kernel'                              
'Elixir.Kernel.CLI'                          
'Elixir.Kernel.ErrorHandler'                 
'Elixir.Kernel.LexicalTracker'               
'Elixir.Kernel.ParallelCompiler'             
'Elixir.Kernel.ParallelRequire'              
'Elixir.Kernel.SpecialForms'                 
'Elixir.Kernel.Typespec'                     
'Elixir.Kernel.Utils'                        
'Elixir.KeyError'                            
'Elixir.Keyword'                             
'Elixir.List'                                
'Elixir.List.Chars'                          
'Elixir.List.Chars.Atom'                     
'Elixir.List.Chars.BitString'                
'Elixir.List.Chars.Float'                    
'Elixir.List.Chars.Integer'                  
'Elixir.List.Chars.List'                     
'Elixir.Macro'                               
'Elixir.Macro.Env'                           
'Elixir.Map'                                 
'Elixir.MapSet'                              
'Elixir.MatchError'                          
'Elixir.Module'                              
'Elixir.Module.Checker'                      
'Elixir.Module.LocalsTracker'                
'Elixir.Module.ParallelChecker'              
'Elixir.Module.Types'                        
'Elixir.Module.Types.Expr'                   
'Elixir.Module.Types.Helpers'                
'Elixir.Module.Types.Infer'                  
'Elixir.Module.Types.Pattern'                
'Elixir.NaiveDateTime'                       
'Elixir.Node'                                
'Elixir.OptionParser'                        
'Elixir.OptionParser.ParseError'             
'Elixir.Path'                                
'Elixir.Path.Wildcard'                       
'Elixir.Port'                                
'Elixir.Process'                             
'Elixir.Protocol'                            
'Elixir.Protocol.UndefinedError'             
'Elixir.Range'                               
'Elixir.Record'                              
'Elixir.Record.Extractor'                    
'Elixir.Regex'                               
'Elixir.Regex.CompileError'                  
'Elixir.Registry'                            
'Elixir.Registry.Partition'                  
'Elixir.Registry.Supervisor'                 
'Elixir.RuntimeError'                        
'Elixir.Set'                                 
'Elixir.Stream'                              
'Elixir.Stream.Reducers'                     
'Elixir.String'                              
'Elixir.String.Break'                        
'Elixir.String.Casing'                       
'Elixir.String.Chars'                        
'Elixir.String.Chars.Atom'                   
'Elixir.String.Chars.BitString'              
'Elixir.String.Chars.Date'                    
'Elixir.String.Chars.DateTime'               
'Elixir.String.Chars.Float'                  
'Elixir.String.Chars.Integer'                
'Elixir.String.Chars.List'                   
'Elixir.String.Chars.NaiveDateTime'          
'Elixir.String.Chars.Time'                   
'Elixir.String.Chars.URI'                    
'Elixir.String.Chars.Version'                
'Elixir.String.Chars.Version.Requirement'    
'Elixir.String.Tokenizer'                    
'Elixir.String.Unicode'                      
'Elixir.StringIO'                            
'Elixir.Supervisor'                          
'Elixir.Supervisor.Default'                  
'Elixir.Supervisor.Spec'                     
'Elixir.SyntaxError'                         
'Elixir.System'                              
'Elixir.SystemLimitError'                    
'Elixir.Task'                                
'Elixir.Task.Supervised'                     
'Elixir.Task.Supervisor'                     
'Elixir.Time'                                
'Elixir.TokenMissingError'                   
'Elixir.TryClauseError'                      
'Elixir.Tuple'                               
'Elixir.URI'                                 
'Elixir.UndefinedFunctionError'              
'Elixir.UnicodeConversionError'              
'Elixir.Version'                             
'Elixir.Version.InvalidRequirementError'     
'Elixir.Version.InvalidVersionError'         
'Elixir.Version.Parser'                      
'Elixir.Version.Requirement'                 
'Elixir.WithClauseError'

Maybe it’s something new in Erlang? I have latest version:

Erlang/OTP 23 [erts-11.0.3] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [hipe]

Eshell V11.0.3

The only difference here is that I have installed Erlang and Elixir by asdf, so ebin path is different, but rest is 1:1 and works even without any project.

1 Like

@Eiji could u please share the install procedure please
Thanks

Those links should give you enough information:

  1. version manager
  2. erlang plug-in
  3. elixir plug-in

Then when the system started the shell knew of all the modules. It saves you some work. :smile:

Thanks @Eiji and @rvirding

I have tested some functions for Elixir in the erlang terminal , and their are failing

(hudson@localhost)5> 'Elixir.String':downcase("hudson").
** exception error: no function clause matching 'Elixir.String':downcase("hudson",default) (lib/string.ex, line 785)
(hudson@localhost)6> 'Elixir.String':downcase("hudson","utf-8").
** exception error: no function clause matching 'Elixir.String':downcase("hudson","utf-8") (lib/string.ex, line 785)
(hudson@localhost)7> 'Elixir.String':downcase("hudson",default).
** exception error: no function clause matching 'Elixir.String':downcase("hudson",default) (lib/string.ex, line 785)

@hudson2010 If I remember correctly Erlang:

  1. " (double quotes) creates in Erlang the same that Elixir is creating with ' (single quote) i.e. charlist
  2. Not sure about UTF-8 binaries, but in Erlang to create binary you need this syntax: <<"Your binary goes here">>.
1> code:add_path("/home/…/.asdf/installs/elixir/1.10.4-otp-23/lib/elixir/ebin/").
true
2> application:start(compiler).                                                     
ok
3> application:start(elixir).
ok
4> 'Elixir.String':downcase(<<"TEST">>).
<<"test">>

For more information please take a look at Strings on Elixir School page.

1 Like

Thanks @Eiji

I found that it is sometimes easy to make a call to unicode:characters_to_binary/1 on strings before passing them to Elixir, if Erlang strings are used heavily in the code already.