(This is a reply to a bug report, I think that a mailing-list reply is
more fitting in this case since you might have more questions.)
1. Your files depend on a particular `DG' collection -- it's usually
best to avoid such things when you submit bug reports.
2. There is no need to do (require scheme), since the `racket'
language is generally a superset. You also don't need to
explicitly use `display' for toplevel values -- just leaving the
expressions in the file will get them printed.
3. You're using `flatten' and `display-true/false-elements' as
something that is much better done with `filter'. For example,
here's a complete rewrite of your code that makes it shorter (but
still buggy):
#lang racket
(provide dir-list)
(define (dir-list-files path mode)
(filter file-exists? (directory-list path)))
(define (dir-list-subdirs path mode)
(filter-not file-exists? (directory-list path)))
(define (dir-list-both path mode)
(directory-list path))
(define (dir-list path mode)
(case mode
[(files) (dir-list-files path mode)]
[(subdirs) (dir-list-subdirs path mode)]
[(both) (dir-list-both path mode)]))
4. But even better -- it's now clear that the only difference is the
filtering that you do, so an expected improvement is to fold the
`directory-list's into a single function:
#lang racket
(provide dir-list)
(define (dir-list path mode)
(define paths (directory-list path))
(case mode
[(files) (filter file-exists? paths)]
[(subdirs) (filter-not file-exists? paths)]
[(both) paths]))
5. That code still has a bug which exists in your original code. The
thing is that `directory-list' produces paths that exist in the
directory, but they're not complete paths. Therefore, if you're
currently in "/foo" and use the above function with "/bar", you get
a list of paths from "/bar" (correctly), and then you filter them
based on whether they exist in "/foo" (incorrectly). One way to
resolve this is to build and return paths that extend the input
directory:
#lang racket
(provide dir-list)
(define (dir-list path mode)
(define paths
(map (λ (p) (build-path path p)) (directory-list path)))
(case mode
[(files) (filter file-exists? paths)]
[(subdirs) (filter-not file-exists? paths)]
[(both) paths]))
But this changes the code since it returns the extended paths
(which might be what you want).
6. An alternative which preserves the same results is to just change
the current directory for the filtering, or just as well for the
whole function:
#lang racket
(provide dir-list)
(define (dir-list path mode)
(parameterize ([current-directory path])
(define paths (directory-list))
(case mode
[(files) (filter file-exists? paths)]
[(subdirs) (filter-not file-exists? paths)]
[(both) paths])))
> *** Description:
> ;I have included the content of 2 files below.
> ;The first file content defines module and function called "dir-list" and a
> call to dir-list. Running this file succeeds in
> returning a dir list, a list of the files in a specified directory.
> ;The second file contains same call to dir-list. Running this file fails. It
> returns the empty list (). It should return a list of files. Why not? How
> can I fix this?
>
> ;---FIRST FILE---
> #lang racket
> (require scheme)
> (require DG/all/list-to-string)
> (require DG/all/display2)
>
> (provide dir-list)
>
> (define (display-true-elements x y) ;(my-display x y)
> (cond ((eq? x #t) y)
> (else null)
> ))
>
> (define (display-false-elements x y) ;(my-display x y)
> (cond ((eq? x #f) y)
> (else null)
> ))
>
> (define dir-list-files
> (lambda (path mode)
> (let* (
> (a (directory-list path))
> (d (map (lambda (x) (file-exists? x)) (directory-list path)))
> )
> ;(display
> (flatten
> (map (lambda (number1 number2)
> (display-true-elements number1 number2))
> d ;list1
> a) ;list2
> ;)
> )
> )))
>
> (define dir-list-subdirs
> (lambda (path mode)
> (let* (
> (a (directory-list path))
> (d (map (lambda (x) (file-exists? x)) (directory-list path)))
> )
> ;(display
> (flatten
> (map (lambda (number1 number2)
> (display-false-elements number1 number2))
> d ;list1
> a) ;list2
> ;)
> )
> )))
>
> (define dir-list-both
> (lambda (path mode)
> ;(display
> (directory-list path)
> ;)
> ))
>
> (define dir-list
> (lambda (path mode)
> (cond
> ((eq? mode 'files) (dir-list-files path mode))
> ((eq? mode 'subdirs) (dir-list-subdirs path mode))
> ((eq? mode 'both) (dir-list-both path mode))
> )
> ))
>
> ;(display (dir-list
> "/home/don/.plt-scheme/4.2.1/collects/DG/test/copy/folder1" 'files)) ;=>
> Returns list of files.
>
> ;---SECOND FILE---
> #lang racket
> (require scheme)
> (require DG/all/dir-list)
>
> (display
> (dir-list "/home/don/.plt-scheme/4.2.1/collects/DG/test/copy/folder1" 'files)
> ) ;=> Returns () as list of files.
>
> *** How to repeat:
> 1) Execute first file. Returns list of files, not subdirectories.
> 2) Execute second file, which simply calls first file. Returns erroneous
> empty list. Should return list of files, not subdirectories.
--
((lambda (x) (x x)) (lambda (x) (x x))) Eli Barzilay:
http://barzilay.org/ Maze is Life!
____________________
Racket Users list:
http://lists.racket-lang.org/users
